package com.sc.utils;

import cn.hutool.core.util.ObjectUtil;
import com.sc.constants.TriggerStatusEnum;
import com.sc.dto.JobQuery;
import com.sc.model.XxlJobInfoAddParam;
import com.sc.service.XxlJobService;
import com.sc.vo.JobInfoPageItem;
import com.sc.vo.JobInfoPageResult;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 *@author shen chen
 *@since 2023-11-22
 * 封装了 XxlJobService 的一些方法,便于业务开发整合而成的工具类
 */

public class XxlJobUtils {

    public static XxlJobService xxlJobService;

    public XxlJobUtils(XxlJobService xxlJobService) {
        XxlJobUtils.xxlJobService = xxlJobService;
    }

    /**
     * 分页查询任务数据
     * @param jobQuery 任务查询条件
     * @return 任务数据
     */
    public static List<JobInfoPageItem> pageList(JobQuery jobQuery) {

        JobInfoPageResult result = xxlJobService.pageList(jobQuery);
        if (ObjectUtil.isEmpty(result) || ObjectUtil.isEmpty(result.getData())) {
            return new ArrayList<>();
        }
        return result.getData();
    }

    /**
     * 分页查询任务数据
     * @param executorHandler 任务执行器
     * @param triggerStatus 任务状态
     * @return 任务数据
     */
    public static List<JobInfoPageItem> pageList(String executorHandler, TriggerStatusEnum triggerStatus) {
        JobQuery jobQuery = new JobQuery();
        jobQuery.setExecutorHandler(executorHandler);
        jobQuery.setTriggerStatus(triggerStatus);
        List<JobInfoPageItem> itemList = pageList(jobQuery);
        if (ObjectUtil.isEmpty(itemList)) {
            return new ArrayList<>();
        }
        return itemList;
    }

    /**
     * 分页查询任务数据
     * @param executorHandler 任务执行器
     * @return 任务数据
     */
    public static List<JobInfoPageItem> pageList(String executorHandler) {
        return pageList(executorHandler, TriggerStatusEnum.ALL);
    }

    /**
     * 分页查询任务数据
     * @param executorHandler 任务执行器
     * @param author 任务创建者
     * @return 任务数据
     */
    public static JobInfoPageItem getJobInfoPageItem(String executorHandler, Object author) {
        JobQuery jobQuery = new JobQuery();
        jobQuery.setTriggerStatus(TriggerStatusEnum.ALL);
        jobQuery.setExecutorHandler(executorHandler);
        jobQuery.setAuthor(String.valueOf(author));
        JobInfoPageResult result = xxlJobService.pageList(jobQuery);
        if (ObjectUtil.isEmpty(result)) {
            return null;
        }
        return result.getData().get(0);
    }

    /**
     * 修改任务
     * @param jobInfoPageItem 任务数据
     */
    public static void update(JobInfoPageItem jobInfoPageItem) {
        xxlJobService.update(jobInfoPageItem);
    }

    /**
     * 修改任务
     * @param executorHandler 任务执行器
     * @param author 任务创建者
     * @param scheduleConf 任务调度配置
     */
    public static JobInfoPageItem update(String executorHandler, Object author, String scheduleConf) {
        if (ObjectUtil.isEmpty(executorHandler) || ObjectUtil.isEmpty(scheduleConf)) {
            return null;
        }

        JobInfoPageItem jobInfoPageItem = getJobInfoPageItem(executorHandler, author);
        if (ObjectUtil.isEmpty(jobInfoPageItem)) {
            return null;
        }
        jobInfoPageItem.setScheduleConf(scheduleConf);
        update(jobInfoPageItem);

        return jobInfoPageItem;
    }

    /**
     * 修改任务
     * @param executorHandler 任务执行器
     * @param author 任务创建者
     * @param scheduleConf 任务调度配置
     * @param state 任务状态
     */
    public static void update(String executorHandler, Object author, String scheduleConf, Integer state) {

        JobInfoPageItem jobInfoPageItem = update(executorHandler, author, scheduleConf);
        if (ObjectUtil.isEmpty(jobInfoPageItem)) {
            return;
        }
        if (ObjectUtil.equals(state, 1)) {
            start(jobInfoPageItem.getId());
        } else {
            stop(jobInfoPageItem.getId());
        }
    }

    /**
     * 启动任务
     * @param id 任务id
     */
    public static void start(int id) {
        xxlJobService.start(id);
    }

    /**
     * 启动任务
     * @param executorHandler 任务执行器
     * @param author 任务创建者
     */
    public static void start(String executorHandler, Object author) {
        JobInfoPageItem item = getJobInfoPageItem(executorHandler, author);
        if (ObjectUtil.isEmpty(item)) {
            throw new RuntimeException("该任务不存在");
        }
        start(item.getId());
    }

    /**
     * 启动任务
     * @param executorHandler 任务执行器
     * @param author 任务创建者
     * @param scheduleConf  任务调度配置
     * @param jobDesc 任务描述
     */
    public static void start(String executorHandler, Object author, String scheduleConf, String jobDesc) {
        start(executorHandler, author, scheduleConf, jobDesc, "");
    }


    /**
     * 启动任务
     * @param executorHandler 任务执行器
     * @param author 任务创建者
     * @param scheduleConf  任务调度配置
     * @param jobDesc 任务描述
     * @param executorParam 任务执行参数
     */
    public static void start(String executorHandler, Object author, String scheduleConf, String jobDesc, String executorParam) {
        Integer taskId = add(executorHandler, author, scheduleConf, jobDesc, executorParam);
        start(taskId);
    }

    /**
     * 添加任务
     * @param executorHandler 任务执行器
     * @param author 任务创建者
     * @param scheduleConf  任务调度配置
     * @param jobDesc 任务描述
     * @return 任务id
     */
    public static Integer add(String executorHandler, Object author, String scheduleConf, String jobDesc) {
        return add(executorHandler, author, scheduleConf, jobDesc, "");
    }

    /**
     * 添加任务
     * @param executorHandler 任务执行器
     * @param author 任务创建者
     * @param scheduleConf  任务调度配置
     * @param jobDesc 任务描述
     * @param executorParam 任务执行参数
     * @return 任务id
     */
    public static Integer add(String executorHandler, Object author, String scheduleConf, String jobDesc, Object executorParam) {
        XxlJobInfoAddParam addParam = new XxlJobInfoAddParam();
        addParam.setExecutorHandler(executorHandler);
        addParam.setAuthor(String.valueOf(author));
        addParam.setScheduleConf(scheduleConf);
        addParam.setJobDesc(jobDesc);
        addParam.setExecutorParam(String.valueOf(executorParam));
        return xxlJobService.add(addParam);
    }

    /**
     * 开始一次性任务
     * 删除使用 removeByCustomId
     * @param customId 自定义id
     * @param triggerTime 触发时间
     * @param executorParam 执行参数
     * @param executorHandler 执行器
     */
    public static void startJustExecuteOnceJob(String customId, Date triggerTime, String executorParam, String executorHandler) {
        start(addJustExecuteOnceJob(customId, triggerTime, executorParam, executorHandler));
    }


    /**
     * 添加一次性任务
     * 删除使用 removeByCustomId
     * @param customId 自定义id
     * @param triggerTime 触发时间
     * @param executorParam 执行参数
     * @param executorHandler 执行器
     * @return 任务id
     */
    public static Integer addJustExecuteOnceJob(String customId, Date triggerTime, String executorParam, String executorHandler) {
        return xxlJobService.addJustExecuteOnceJob(customId, triggerTime, executorParam, executorHandler);
    }

    /**
     * 停止任务
     * @param id 任务id
     */
    public static void stop(int id) {
        xxlJobService.stop(id);
    }


    /**
     * 停止任务
     * @param executorHandler 任务执行器
     * @param author    任务创建者
     */
    public static void stop(String executorHandler, Object author) {
        JobInfoPageItem item = getJobInfoPageItem(executorHandler, author);
        if (ObjectUtil.isEmpty(item)) {
            throw new RuntimeException("该任务不存在");
        }
        xxlJobService.stop(item.getId());
    }


    /**
     * 删除任务
     * @param taskId 任务id
     */
    public static void remove(int taskId) {
        xxlJobService.remove(taskId);
    }

    /**
     * 通过 自定义id 删除任务
     * @param customId  自定义id
     */
    public static void removeByCustomId(String customId) {
        Integer taskId = xxlJobService.getJobIdByCustomId(customId);
        remove(taskId);
    }

    /**
     * 删除任务
     * @param triggerStatusEnum 任务状态
     * @param jobDesc 任务描述
     * @param livingStandardHandler     任务执行器
     * @param author 任务创建者
     */
    public static void remove(TriggerStatusEnum triggerStatusEnum, String jobDesc, String livingStandardHandler, String author) {
        xxlJobService.remove(triggerStatusEnum, jobDesc, livingStandardHandler, author);
    }

    /**
     * 删除任务
     * @param jobDesc 任务描述
     * @param livingStandardHandler     任务执行器
     * @param author 任务创建者
     */
    public static void remove(String jobDesc, String livingStandardHandler, String author) {
        remove(TriggerStatusEnum.ALL, jobDesc, livingStandardHandler, author);
    }

    /**
     * 删除任务
     * @param livingStandardHandler     任务执行器
     * @param author 任务创建者
     */
    public static void remove(String livingStandardHandler, Object author) {
        remove(TriggerStatusEnum.ALL, null, livingStandardHandler, String.valueOf(author));
    }

    /**
     * 删除任务
     * @param livingStandardHandler     任务执行器
     */
    public static void remove(String livingStandardHandler) {
        remove(TriggerStatusEnum.ALL, null, livingStandardHandler, null);
    }


}
